{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import warnings\n",
    "\n",
    "if not sys.warnoptions:\n",
    "    warnings.simplefilter('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from datetime import datetime\n",
    "from datetime import timedelta\n",
    "from tqdm import tqdm\n",
    "sns.set()\n",
    "tf.compat.v1.random.set_random_seed(1234)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Date</th>\n",
       "      <th>Open</th>\n",
       "      <th>High</th>\n",
       "      <th>Low</th>\n",
       "      <th>Close</th>\n",
       "      <th>Adj Close</th>\n",
       "      <th>Volume</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2016-11-02</td>\n",
       "      <td>778.200012</td>\n",
       "      <td>781.650024</td>\n",
       "      <td>763.450012</td>\n",
       "      <td>768.700012</td>\n",
       "      <td>768.700012</td>\n",
       "      <td>1872400</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2016-11-03</td>\n",
       "      <td>767.250000</td>\n",
       "      <td>769.950012</td>\n",
       "      <td>759.030029</td>\n",
       "      <td>762.130005</td>\n",
       "      <td>762.130005</td>\n",
       "      <td>1943200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2016-11-04</td>\n",
       "      <td>750.659973</td>\n",
       "      <td>770.359985</td>\n",
       "      <td>750.560974</td>\n",
       "      <td>762.020020</td>\n",
       "      <td>762.020020</td>\n",
       "      <td>2134800</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2016-11-07</td>\n",
       "      <td>774.500000</td>\n",
       "      <td>785.190002</td>\n",
       "      <td>772.549988</td>\n",
       "      <td>782.520020</td>\n",
       "      <td>782.520020</td>\n",
       "      <td>1585100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2016-11-08</td>\n",
       "      <td>783.400024</td>\n",
       "      <td>795.632996</td>\n",
       "      <td>780.190002</td>\n",
       "      <td>790.510010</td>\n",
       "      <td>790.510010</td>\n",
       "      <td>1350800</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Date        Open        High         Low       Close   Adj Close  \\\n",
       "0  2016-11-02  778.200012  781.650024  763.450012  768.700012  768.700012   \n",
       "1  2016-11-03  767.250000  769.950012  759.030029  762.130005  762.130005   \n",
       "2  2016-11-04  750.659973  770.359985  750.560974  762.020020  762.020020   \n",
       "3  2016-11-07  774.500000  785.190002  772.549988  782.520020  782.520020   \n",
       "4  2016-11-08  783.400024  795.632996  780.190002  790.510010  790.510010   \n",
       "\n",
       "    Volume  \n",
       "0  1872400  \n",
       "1  1943200  \n",
       "2  2134800  \n",
       "3  1585100  \n",
       "4  1350800  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('../dataset/GOOG-year.csv')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.112708</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.090008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.089628</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.160459</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.188066</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0\n",
       "0  0.112708\n",
       "1  0.090008\n",
       "2  0.089628\n",
       "3  0.160459\n",
       "4  0.188066"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minmax = MinMaxScaler().fit(df.iloc[:, 4:5].astype('float32')) # Close index\n",
    "df_log = minmax.transform(df.iloc[:, 4:5].astype('float32')) # Close index\n",
    "df_log = pd.DataFrame(df_log)\n",
    "df_log.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Split train and test\n",
    "\n",
    "I will cut the dataset to train and test datasets,\n",
    "\n",
    "1. Train dataset derived from starting timestamp until last 30 days\n",
    "2. Test dataset derived from last 30 days until end of the dataset\n",
    "\n",
    "So we will let the model do forecasting based on last 30 days, and we will going to repeat the experiment for 10 times. You can increase it locally if you want, and tuning parameters will help you by a lot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((252, 7), (222, 1), (30, 1))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_size = 30\n",
    "simulation_size = 10\n",
    "\n",
    "df_train = df_log.iloc[:-test_size]\n",
    "df_test = df_log.iloc[-test_size:]\n",
    "df.shape, df_train.shape, df_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model:\n",
    "    def __init__(\n",
    "        self,\n",
    "        learning_rate,\n",
    "        num_layers,\n",
    "        size,\n",
    "        size_layer,\n",
    "        output_size,\n",
    "        forget_bias = 0.1,\n",
    "    ):\n",
    "        def lstm_cell(size_layer):\n",
    "            return tf.nn.rnn_cell.GRUCell(size_layer)\n",
    "        \n",
    "        with tf.variable_scope('forward', reuse = False):\n",
    "            rnn_cells_forward = tf.nn.rnn_cell.MultiRNNCell(\n",
    "                [lstm_cell(size_layer) for _ in range(num_layers)],\n",
    "                state_is_tuple = False,\n",
    "            )\n",
    "            self.X_forward = tf.placeholder(tf.float32, (None, None, size))\n",
    "            drop_forward = tf.contrib.rnn.DropoutWrapper(\n",
    "                rnn_cells_forward, output_keep_prob = forget_bias\n",
    "            )\n",
    "            self.hidden_layer_forward = tf.placeholder(\n",
    "                tf.float32, (None, num_layers * size_layer)\n",
    "            )\n",
    "            self.outputs_forward, self.last_state_forward = tf.nn.dynamic_rnn(\n",
    "                drop_forward,\n",
    "                self.X_forward,\n",
    "                initial_state = self.hidden_layer_forward,\n",
    "                dtype = tf.float32,\n",
    "            )\n",
    "\n",
    "        with tf.variable_scope('backward', reuse = False):\n",
    "            rnn_cells_backward = tf.nn.rnn_cell.MultiRNNCell(\n",
    "                [lstm_cell(size_layer) for _ in range(num_layers)],\n",
    "                state_is_tuple = False,\n",
    "            )\n",
    "            self.X_backward = tf.placeholder(tf.float32, (None, None, size))\n",
    "            drop_backward = tf.contrib.rnn.DropoutWrapper(\n",
    "                rnn_cells_backward, output_keep_prob = forget_bias\n",
    "            )\n",
    "            self.hidden_layer_backward = tf.placeholder(\n",
    "                tf.float32, (None, num_layers * size_layer)\n",
    "            )\n",
    "            self.outputs_backward, self.last_state_backward = tf.nn.dynamic_rnn(\n",
    "                drop_backward,\n",
    "                self.X_backward,\n",
    "                initial_state = self.hidden_layer_backward,\n",
    "                dtype = tf.float32,\n",
    "            )\n",
    "\n",
    "        self.outputs = self.outputs_backward - self.outputs_forward\n",
    "        self.Y = tf.placeholder(tf.float32, (None, output_size))\n",
    "        self.logits = tf.layers.dense(self.outputs[-1], output_size)\n",
    "        self.cost = tf.reduce_mean(tf.square(self.Y - self.logits))\n",
    "        self.optimizer = tf.train.AdamOptimizer(learning_rate).minimize(\n",
    "            self.cost\n",
    "        )\n",
    "        \n",
    "def calculate_accuracy(real, predict):\n",
    "    real = np.array(real) + 1\n",
    "    predict = np.array(predict) + 1\n",
    "    percentage = 1 - np.sqrt(np.mean(np.square((real - predict) / real)))\n",
    "    return percentage * 100\n",
    "\n",
    "def anchor(signal, weight):\n",
    "    buffer = []\n",
    "    last = signal[0]\n",
    "    for i in signal:\n",
    "        smoothed_val = last * weight + (1 - weight) * i\n",
    "        buffer.append(smoothed_val)\n",
    "        last = smoothed_val\n",
    "    return buffer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_layers = 1\n",
    "size_layer = 128\n",
    "timestamp = 5\n",
    "epoch = 300\n",
    "dropout_rate = 0.8\n",
    "future_day = test_size\n",
    "learning_rate = 0.01"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forecast():\n",
    "    tf.reset_default_graph()\n",
    "    modelnn = Model(\n",
    "        learning_rate, num_layers, df_log.shape[1], size_layer, df_log.shape[1], dropout_rate\n",
    "    )\n",
    "    sess = tf.InteractiveSession()\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    date_ori = pd.to_datetime(df.iloc[:, 0]).tolist()\n",
    "\n",
    "    pbar = tqdm(range(epoch), desc = 'train loop')\n",
    "    for i in pbar:\n",
    "        init_value_forward = np.zeros((1, num_layers * size_layer))\n",
    "        init_value_backward = np.zeros((1, num_layers * size_layer))\n",
    "        total_loss, total_acc = [], []\n",
    "        for k in range(0, df_train.shape[0] - 1, timestamp):\n",
    "            index = min(k + timestamp, df_train.shape[0] - 1)\n",
    "            batch_x_forward = np.expand_dims(\n",
    "                df_train.iloc[k : index, :].values, axis = 0\n",
    "            )\n",
    "            batch_x_backward = np.expand_dims(\n",
    "                np.flip(df_train.iloc[k : index, :].values, axis = 0), axis = 0\n",
    "            )\n",
    "            batch_y = df_train.iloc[k + 1 : index + 1, :].values\n",
    "            logits, last_state_forward, last_state_backward, _, loss = sess.run(\n",
    "                [\n",
    "                    modelnn.logits,\n",
    "                    modelnn.last_state_forward,\n",
    "                    modelnn.last_state_backward,\n",
    "                    modelnn.optimizer,\n",
    "                    modelnn.cost,\n",
    "                ],\n",
    "                feed_dict = {\n",
    "                    modelnn.X_forward: batch_x_forward,\n",
    "                    modelnn.X_backward: batch_x_backward,\n",
    "                    modelnn.Y: batch_y,\n",
    "                    modelnn.hidden_layer_forward: init_value_forward,\n",
    "                    modelnn.hidden_layer_backward: init_value_backward,\n",
    "                },\n",
    "            )\n",
    "            init_value_forward = last_state_forward\n",
    "            init_value_backward = last_state_backward\n",
    "            total_loss.append(loss)\n",
    "            total_acc.append(calculate_accuracy(batch_y[:, 0], logits[:, 0]))\n",
    "        pbar.set_postfix(cost = np.mean(total_loss), acc = np.mean(total_acc))\n",
    "    \n",
    "    future_day = test_size\n",
    "\n",
    "    output_predict = np.zeros((df_train.shape[0] + future_day, df_train.shape[1]))\n",
    "    output_predict[0] = df_train.iloc[0]\n",
    "    upper_b = (df_train.shape[0] // timestamp) * timestamp\n",
    "    init_value_forward = np.zeros((1, num_layers * size_layer))\n",
    "    init_value_backward = np.zeros((1, num_layers * size_layer))\n",
    "\n",
    "    for k in range(0, (df_train.shape[0] // timestamp) * timestamp, timestamp):\n",
    "        batch_x_forward = np.expand_dims(\n",
    "        df_train.iloc[k : k + timestamp, :], axis = 0\n",
    "        )\n",
    "        batch_x_backward = np.expand_dims(\n",
    "            np.flip(df_train.iloc[k : k + timestamp, :].values, axis = 0), axis = 0\n",
    "        )\n",
    "        out_logits, last_state_forward, last_state_backward = sess.run(\n",
    "            [\n",
    "                modelnn.logits,\n",
    "                modelnn.last_state_forward,\n",
    "                modelnn.last_state_backward,\n",
    "            ],\n",
    "            feed_dict = {\n",
    "                modelnn.X_forward: batch_x_forward,\n",
    "                modelnn.X_backward: batch_x_backward,\n",
    "                modelnn.hidden_layer_forward: init_value_forward,\n",
    "                modelnn.hidden_layer_backward: init_value_backward,\n",
    "            },\n",
    "        )\n",
    "        init_value_forward = last_state_forward\n",
    "        init_value_backward = last_state_backward\n",
    "        output_predict[k + 1 : k + timestamp + 1, :] = out_logits\n",
    "\n",
    "    if upper_b != df_train.shape[0]:\n",
    "        batch_x_forward = np.expand_dims(df_train.iloc[upper_b:, :], axis = 0)\n",
    "        batch_x_backward = np.expand_dims(\n",
    "            np.flip(df_train.iloc[upper_b:, :].values, axis = 0), axis = 0\n",
    "        )\n",
    "        out_logits, last_state_forward, last_state_backward = sess.run(\n",
    "            [modelnn.logits, modelnn.last_state_forward, modelnn.last_state_backward],\n",
    "            feed_dict = {\n",
    "                modelnn.X_forward: batch_x_forward,\n",
    "                modelnn.X_backward: batch_x_backward,\n",
    "                modelnn.hidden_layer_forward: init_value_forward,\n",
    "                modelnn.hidden_layer_backward: init_value_backward,\n",
    "            },\n",
    "        )\n",
    "        init_value_forward = last_state_forward\n",
    "        init_value_backward = last_state_backward\n",
    "        output_predict[upper_b + 1 : df_train.shape[0] + 1] = out_logits\n",
    "        future_day -= 1\n",
    "        date_ori.append(date_ori[-1] + timedelta(days = 1))\n",
    "        \n",
    "    init_value_forward = last_state_forward\n",
    "    init_value_backward = last_state_backward\n",
    "    \n",
    "    for i in range(future_day):\n",
    "        o = output_predict[-future_day - timestamp + i:-future_day + i]\n",
    "        o_f = np.flip(o, axis = 0)\n",
    "        out_logits, last_state_forward, last_state_backward = sess.run(\n",
    "            [\n",
    "                modelnn.logits,\n",
    "                modelnn.last_state_forward,\n",
    "                modelnn.last_state_backward,\n",
    "            ],\n",
    "            feed_dict = {\n",
    "                modelnn.X_forward: np.expand_dims(o, axis = 0),\n",
    "                modelnn.X_backward: np.expand_dims(o_f, axis = 0),\n",
    "                modelnn.hidden_layer_forward: init_value_forward,\n",
    "                modelnn.hidden_layer_backward: init_value_backward,\n",
    "            },\n",
    "        )\n",
    "        init_value_forward = last_state_forward\n",
    "        init_value_backward = last_state_backward\n",
    "        output_predict[-future_day + i] = out_logits[-1]\n",
    "        date_ori.append(date_ori[-1] + timedelta(days = 1))\n",
    "    \n",
    "    output_predict = minmax.inverse_transform(output_predict)\n",
    "    deep_future = anchor(output_predict[:, 0], 0.3)\n",
    "    \n",
    "    return deep_future[-test_size:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Logging before flag parsing goes to stderr.\n",
      "W0812 17:35:02.847837 140485361571648 deprecation.py:323] From <ipython-input-6-0ad5fabb14ba>:12: GRUCell.__init__ (from tensorflow.python.ops.rnn_cell_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "This class is equivalent as tf.keras.layers.GRUCell, and will be replaced by that in Tensorflow 2.0.\n",
      "W0812 17:35:02.849749 140485361571648 deprecation.py:323] From <ipython-input-6-0ad5fabb14ba>:17: MultiRNNCell.__init__ (from tensorflow.python.ops.rnn_cell_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "This class is equivalent as tf.keras.layers.StackedRNNCells, and will be replaced by that in Tensorflow 2.0.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0812 17:35:03.166620 140485361571648 lazy_loader.py:50] \n",
      "The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
      "For more information, please see:\n",
      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
      "  * https://github.com/tensorflow/addons\n",
      "  * https://github.com/tensorflow/io (for I/O related ops)\n",
      "If you depend on functionality not listed there, please file an issue.\n",
      "\n",
      "W0812 17:35:03.169869 140485361571648 deprecation.py:323] From <ipython-input-6-0ad5fabb14ba>:30: dynamic_rnn (from tensorflow.python.ops.rnn) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `keras.layers.RNN(cell)`, which is equivalent to this API\n",
      "W0812 17:35:03.361743 140485361571648 deprecation.py:506] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/init_ops.py:1251: calling VarianceScaling.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "W0812 17:35:03.368463 140485361571648 deprecation.py:506] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/rnn_cell_impl.py:564: calling Constant.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "W0812 17:35:03.377521 140485361571648 deprecation.py:506] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/rnn_cell_impl.py:574: calling Zeros.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "W0812 17:35:03.612136 140485361571648 deprecation.py:323] From <ipython-input-6-0ad5fabb14ba>:54: dense (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.dense instead.\n",
      "train loop: 100%|██████████| 300/300 [01:38<00:00,  3.04it/s, acc=97.5, cost=0.00174]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:39<00:00,  3.01it/s, acc=96.7, cost=0.00259]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:39<00:00,  2.99it/s, acc=97.4, cost=0.00178]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:38<00:00,  3.05it/s, acc=96.2, cost=0.00314]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:40<00:00,  2.99it/s, acc=97.4, cost=0.00166]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 6\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:38<00:00,  3.02it/s, acc=97.3, cost=0.00162]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 7\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:40<00:00,  3.00it/s, acc=96.1, cost=0.00347]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:40<00:00,  3.01it/s, acc=96.1, cost=0.004]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 9\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:38<00:00,  3.05it/s, acc=95.3, cost=0.00537]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:38<00:00,  3.05it/s, acc=97.1, cost=0.00213]\n"
     ]
    }
   ],
   "source": [
    "results = []\n",
    "for i in range(simulation_size):\n",
    "    print('simulation %d'%(i + 1))\n",
    "    results.append(forecast())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "accuracies = [calculate_accuracy(df['Close'].iloc[-test_size:].values, r) for r in results]\n",
    "\n",
    "plt.figure(figsize = (15, 5))\n",
    "for no, r in enumerate(results):\n",
    "    plt.plot(r, label = 'forecast %d'%(no + 1))\n",
    "plt.plot(df['Close'].iloc[-test_size:].values, label = 'true trend', c = 'black')\n",
    "plt.legend()\n",
    "plt.title('average accuracy: %.4f'%(np.mean(accuracies)))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
